home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / dix / RCS / main.c,v < prev    next >
Encoding:
Text File  |  1990-02-14  |  18.4 KB  |  650 lines
  1. head     1.1;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.1
  10. date     90.02.14.15.23.31;  author tve;  state Exp;
  11. branches ;
  12. next     ;
  13.  
  14.  
  15. desc
  16. @Original X11R4 distribution
  17. @
  18.  
  19.  
  20.  
  21. 1.1
  22. log
  23. @Initial revision
  24. @
  25. text
  26. @/***********************************************************
  27. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  28. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  29.  
  30.                         All Rights Reserved
  31.  
  32. Permission to use, copy, modify, and distribute this software and its 
  33. documentation for any purpose and without fee is hereby granted, 
  34. provided that the above copyright notice appear in all copies and that
  35. both that copyright notice and this permission notice appear in 
  36. supporting documentation, and that the names of Digital or MIT not be
  37. used in advertising or publicity pertaining to distribution of the
  38. software without specific, written prior permission.  
  39.  
  40. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  41. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  42. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  43. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  44. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  45. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  46. SOFTWARE.
  47.  
  48. ******************************************************************/
  49. /* $XConsortium: main.c,v 5.9 89/10/03 19:57:00 rws Exp $ */
  50.  
  51. #include "X.h"
  52. #include "Xproto.h"
  53. #include "input.h"
  54. #include "scrnintstr.h"
  55. #include "misc.h"
  56. #include "os.h"
  57. #include "windowstr.h"
  58. #include "resource.h"
  59. #include "dixstruct.h"
  60. #include "gcstruct.h"
  61. #include "extension.h"
  62. #include "colormap.h"
  63. #include "cursorstr.h"
  64. #include "opaque.h"
  65. #include "servermd.h"
  66.  
  67. extern long defaultScreenSaverTime;
  68. extern long defaultScreenSaverInterval;
  69. extern int defaultScreenSaverBlanking;
  70. extern int defaultScreenSaverAllowExposures;
  71.  
  72. void ddxGiveUp();
  73.  
  74. extern char *display;
  75. char *ConnectionInfo;
  76. xConnSetupPrefix connSetupPrefix;
  77.  
  78. extern WindowPtr *WindowTable;
  79. extern FontPtr defaultFont;
  80.  
  81. extern void SetInputCheck();
  82. extern void InitProcVectors();
  83. extern void InitEvents();
  84. extern void InitExtensions();
  85. extern void DefineInitialRootWindow();
  86. extern void QueryMinMaxKeyCodes();
  87. extern Bool InitClientResources();
  88. static Bool CreateConnectionBlock();
  89. extern Bool CreateGCperDepthArray();
  90. extern Bool CreateDefaultStipple();
  91. extern void ResetWellKnownSockets();
  92. extern void ResetWindowPrivates();
  93. extern void ResetGCPrivates();
  94. static void FreeScreen();
  95. static void ResetScreenPrivates();
  96.  
  97. PaddingInfo PixmapWidthPaddingInfo[33];
  98. int connBlockScreenStart;
  99.  
  100. static int restart = 0;
  101.  
  102. void
  103. NotImplemented()
  104. {
  105.     FatalError("Not implemented");
  106. }
  107.  
  108. /*
  109.  * This array encodes the answer to the question "what is the log base 2
  110.  * of the number of pixels that fit in a scanline pad unit?"
  111.  * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
  112.  */
  113. static int answer[6][3] = {
  114.     /* pad   pad   pad */
  115.     /*  8     16    32 */
  116.  
  117.     {   3,     4,    5 },    /* 1 bit per pixel */
  118.     {   1,     2,    3 },    /* 4 bits per pixel */
  119.     {   0,     1,    2 },    /* 8 bits per pixel */
  120.     {   ~0,    0,    1 },    /* 16 bits per pixel */
  121.     {   ~0,    ~0,   0 },    /* 24 bits per pixel */
  122.     {   ~0,    ~0,   0 }    /* 32 bits per pixel */
  123. };
  124.  
  125. /*
  126.  * This array gives the answer to the question "what is the first index for
  127.  * the answer array above given the number of bits per pixel?"
  128.  * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
  129.  */
  130. static int indexForBitsPerPixel[ 33 ] = {
  131.     ~0, 0, ~0, ~0,    /* 1 bit per pixel */
  132.     1, ~0, ~0, ~0,    /* 4 bits per pixel */
  133.     2, ~0, ~0, ~0,    /* 8 bits per pixel */
  134.     ~0,~0, ~0, ~0,
  135.     3, ~0, ~0, ~0,    /* 16 bits per pixel */
  136.     ~0,~0, ~0, ~0,
  137.     4, ~0, ~0, ~0,    /* 24 bits per pixel */
  138.     ~0,~0, ~0, ~0,
  139.     5        /* 32 bits per pixel */
  140. };
  141.  
  142. /*
  143.  * This array gives the answer to the question "what is the second index for
  144.  * the answer array above given the number of bits per scanline pad unit?"
  145.  * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
  146.  */
  147. static int indexForScanlinePad[ 33 ] = {
  148.     ~0, ~0, ~0, ~0,
  149.     ~0, ~0, ~0, ~0,
  150.     0,  ~0, ~0, ~0,    /* 8 bits per scanline pad unit */
  151.     ~0, ~0, ~0, ~0,
  152.     1,  ~0, ~0, ~0,    /* 16 bits per scanline pad unit */
  153.     ~0, ~0, ~0, ~0,
  154.     ~0, ~0, ~0, ~0,
  155.     ~0, ~0, ~0, ~0,
  156.     2        /* 32 bits per scanline pad unit */
  157. };
  158.  
  159. main(argc, argv)
  160.     int        argc;
  161.     char    *argv[];
  162. {
  163.     int        i, j, k;
  164.     long    alwaysCheckForInput[2];
  165.  
  166.     /* Notice if we're restart.  Probably this is because we jumped through
  167.      * uninitialized pointer */
  168.     if (restart)
  169.     FatalError("server restarted. Jumped through uninitialized pointer?\n");
  170.     else
  171.     restart = 1;
  172.     /* These are needed by some routines which are called from interrupt
  173.      * handlers, thus have no direct calling path back to main and thus
  174.      * can't be passed argc, argv as parameters */
  175.     argcGlobal = argc;
  176.     argvGlobal = argv;
  177.     display = "0";
  178.     ProcessCommandLine(argc, argv);
  179.  
  180.     alwaysCheckForInput[0] = 0;
  181.     alwaysCheckForInput[1] = 1;
  182.     while(1)
  183.     {
  184.     serverGeneration++;
  185.         ScreenSaverTime = defaultScreenSaverTime;
  186.     ScreenSaverInterval = defaultScreenSaverInterval;
  187.     ScreenSaverBlanking = defaultScreenSaverBlanking;
  188.     ScreenSaverAllowExposures = defaultScreenSaverAllowExposures;
  189.     InitBlockAndWakeupHandlers();
  190.     /* Perform any operating system dependent initializations you'd like */
  191.     OsInit();        
  192.     if(serverGeneration == 1)
  193.     {
  194.         CreateWellKnownSockets();
  195.         InitProcVectors();
  196.         clients = (ClientPtr *)xalloc(MAXCLIENTS * sizeof(ClientPtr));
  197.         if (!clients)
  198.         FatalError("couldn't create client array");
  199.         for (i=1; i<MAXCLIENTS; i++) 
  200.         clients[i] = NullClient;
  201.         serverClient = (ClientPtr)xalloc(sizeof(ClientRec));
  202.         if (!serverClient)
  203.         FatalError("couldn't create server client");
  204.             serverClient->sequence = 0;
  205.             serverClient->closeDownMode = RetainPermanent;
  206.             serverClient->clientGone = FALSE;
  207.             serverClient->lastDrawable = (DrawablePtr)NULL;
  208.         serverClient->lastDrawableID = INVALID;
  209.             serverClient->lastGC = (GCPtr)NULL;
  210.         serverClient->lastGCID = INVALID;
  211.         serverClient->numSaved = 0;
  212.         serverClient->saveSet = (pointer *)NULL;
  213.         serverClient->index = 0;
  214.         serverClient->clientAsMask = (Mask)0;
  215.     }
  216.     else
  217.         ResetWellKnownSockets ();
  218.         clients[0] = serverClient;
  219.         currentMaxClients = 1;
  220.  
  221.     if (!InitClientResources(serverClient))      /* for root resources */
  222.         FatalError("couldn't init server resources");
  223.  
  224.     SetInputCheck(&alwaysCheckForInput[0], &alwaysCheckForInput[1]);
  225.     screenInfo.arraySize = MAXSCREENS;
  226.     screenInfo.numScreens = 0;
  227.     WindowTable = (WindowPtr *)xalloc(MAXSCREENS * sizeof(WindowPtr));
  228.     if (!WindowTable)
  229.         FatalError("couldn't create root window table");
  230.  
  231.     /*
  232.      * Just in case the ddx doesnt supply a format for depth 1 (like qvss).
  233.      */
  234.     j = indexForBitsPerPixel[ 1 ];
  235.     k = indexForScanlinePad[ BITMAP_SCANLINE_PAD ];
  236.     PixmapWidthPaddingInfo[1].padRoundUp = BITMAP_SCANLINE_PAD-1;
  237.     PixmapWidthPaddingInfo[1].padPixelsLog2 = answer[j][k];
  238.      j = indexForBitsPerPixel[8]; /* bits per byte */
  239.      PixmapWidthPaddingInfo[1].padBytesLog2 = answer[j][k];
  240.  
  241.     InitAtoms();
  242.     InitEvents();
  243.     ResetScreenPrivates();
  244.     ResetWindowPrivates();
  245.     ResetGCPrivates();
  246.     InitOutput(&screenInfo, argc, argv);
  247.     if (screenInfo.numScreens < 1)
  248.         FatalError("no screens found");
  249.     InitExtensions(argc, argv);
  250.     for (i = 0; i < screenInfo.numScreens; i++)
  251.     {
  252.         if (!CreateRootWindow(screenInfo.screens[i]))
  253.         FatalError("failed to create root window");
  254.     }
  255.     InitInput(argc, argv);
  256.     if (InitAndStartDevices() != Success)
  257.         FatalError("failed to initialize core devices");
  258.  
  259.     if (SetDefaultFontPath(defaultFontPath) != Success)
  260.         ErrorF("failed to set default font path '%s'", defaultFontPath);
  261.     if (!SetDefaultFont(defaultTextFont))
  262.         FatalError("could not open default font '%s'", defaultTextFont);
  263.     if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0)))
  264.         FatalError("could not open default cursor font '%s'",
  265.                defaultCursorFont);
  266.     for (i = 0; i < screenInfo.numScreens; i++)
  267.         InitRootWindow(WindowTable[i]);
  268.         DefineInitialRootWindow(WindowTable[0]);
  269.  
  270.     if (!CreateConnectionBlock())
  271.         FatalError("could not create connection block info");
  272.  
  273.     Dispatch();
  274.  
  275.     /* Now free up whatever must be freed */
  276.     CloseDownExtensions();
  277.     FreeAllResources();
  278.     CloseDownDevices();
  279.     for (i = screenInfo.numScreens - 1; i >= 0; i--)
  280.     {
  281.         FreeGCperDepth(i);
  282.         FreeDefaultStipple(i);
  283.         (* screenInfo.screens[i]->CloseScreen)(i, screenInfo.screens[i]);
  284.         FreeScreen(screenInfo.screens[i]);
  285.         screenInfo.numScreens = i;
  286.     }
  287.     xfree(WindowTable);
  288.  
  289.         CloseFont(defaultFont, (Font)0);
  290.         defaultFont = (FontPtr)NULL;
  291.  
  292.     if (dispatchException & DE_TERMINATE)
  293.     {
  294.         ddxGiveUp();
  295.         break;
  296.     }
  297.  
  298.     xfree(ConnectionInfo);
  299.     }
  300.     exit(0);
  301. }
  302.  
  303. static int padlength[4] = {0, 3, 2, 1};
  304.  
  305. static Bool
  306. CreateConnectionBlock()
  307. {
  308.     xConnSetup setup;
  309.     xWindowRoot root;
  310.     xDepth    depth;
  311.     xVisualType visual;
  312.     xPixmapFormat format;
  313.     unsigned long vid;
  314.     int i, j, k,
  315.         lenofblock,
  316.         sizesofar = 0;
  317.     char *pBuf;
  318.  
  319.     
  320.     /* Leave off the ridBase and ridMask, these must be sent with 
  321.        connection */
  322.  
  323.     setup.release = VENDOR_RELEASE;
  324.     /*
  325.      * per-server image and bitmap parameters are defined in Xmd.h
  326.      */
  327.     setup.imageByteOrder = screenInfo.imageByteOrder;
  328.     setup.bitmapScanlineUnit  = screenInfo.bitmapScanlineUnit;
  329.     setup.bitmapScanlinePad = screenInfo.bitmapScanlinePad;
  330.     setup.bitmapBitOrder = screenInfo.bitmapBitOrder;
  331.     setup.motionBufferSize = NumMotionEvents();
  332.     setup.numRoots = screenInfo.numScreens;
  333.     setup.nbytesVendor = strlen(VENDOR_STRING); 
  334.     setup.numFormats = screenInfo.numPixmapFormats;
  335.     setup.maxRequestSize = MAX_REQUEST_SIZE;
  336.     QueryMinMaxKeyCodes(&setup.minKeyCode, &setup.maxKeyCode);
  337.     
  338.     lenofblock = sizeof(xConnSetup) + 
  339.             ((setup.nbytesVendor + 3) & ~3) +
  340.         (setup.numFormats * sizeof(xPixmapFormat)) +
  341.             (setup.numRoots * sizeof(xWindowRoot));
  342.     ConnectionInfo = (char *) xalloc(lenofblock);
  343.     if (!ConnectionInfo)
  344.     return FALSE;
  345.  
  346.     bcopy((char *)&setup, ConnectionInfo, sizeof(xConnSetup));
  347.     sizesofar = sizeof(xConnSetup);
  348.     pBuf = ConnectionInfo + sizeof(xConnSetup);
  349.  
  350.     bcopy(VENDOR_STRING, pBuf, (int)setup.nbytesVendor);
  351.     sizesofar += setup.nbytesVendor;
  352.     pBuf += setup.nbytesVendor;
  353.     i = padlength[setup.nbytesVendor & 3];
  354.     sizesofar += i;
  355.     while (--i >= 0)
  356.         *pBuf++ = 0;
  357.     
  358.     for (i=0; i<screenInfo.numPixmapFormats; i++)
  359.     {
  360.     format.depth = screenInfo.formats[i].depth;
  361.     format.bitsPerPixel = screenInfo.formats[i].bitsPerPixel;
  362.     format.scanLinePad = screenInfo.formats[i].scanlinePad;
  363.     bcopy((char *)&format, pBuf, sizeof(xPixmapFormat));
  364.     pBuf += sizeof(xPixmapFormat);
  365.     sizesofar += sizeof(xPixmapFormat);
  366.     }
  367.  
  368.     connBlockScreenStart = sizesofar;
  369.     for (i=0; i<screenInfo.numScreens; i++) 
  370.     {
  371.     ScreenPtr    pScreen;
  372.     DepthPtr    pDepth;
  373.     VisualPtr    pVisual;
  374.  
  375.     pScreen = screenInfo.screens[i];
  376.     root.windowId = WindowTable[i]->drawable.id;
  377.     root.defaultColormap = pScreen->defColormap;
  378.     root.whitePixel = pScreen->whitePixel;
  379.     root.blackPixel = pScreen->blackPixel;
  380.     root.currentInputMask = 0;    /* filled in when sent */
  381.     root.pixWidth = pScreen->width;
  382.     root.pixHeight = pScreen->height;
  383.     root.mmWidth = pScreen->mmWidth;
  384.     root.mmHeight = pScreen->mmHeight;
  385.     root.minInstalledMaps = pScreen->minInstalledCmaps;
  386.     root.maxInstalledMaps = pScreen->maxInstalledCmaps; 
  387.     root.rootVisualID = pScreen->rootVisual;        
  388.     root.backingStore = pScreen->backingStoreSupport;
  389.     root.saveUnders = pScreen->saveUnderSupport != NotUseful;
  390.     root.rootDepth = pScreen->rootDepth;
  391.     root.nDepths = pScreen->numDepths;
  392.     bcopy((char *)&root, pBuf, sizeof(xWindowRoot));
  393.     sizesofar += sizeof(xWindowRoot);
  394.     pBuf += sizeof(xWindowRoot);
  395.  
  396.     pDepth = pScreen->allowedDepths;
  397.     for(j = 0; j < pScreen->numDepths; j++, pDepth++)
  398.     {
  399.         lenofblock += sizeof(xDepth) + 
  400.             (pDepth->numVids * sizeof(xVisualType));
  401.         pBuf = (char *)xrealloc(ConnectionInfo, lenofblock);
  402.         if (!pBuf)
  403.         {
  404.         xfree(ConnectionInfo);
  405.         return FALSE;
  406.         }
  407.         ConnectionInfo = pBuf;
  408.         pBuf += sizesofar;            
  409.         depth.depth = pDepth->depth;
  410.         depth.nVisuals = pDepth->numVids;
  411.         bcopy((char *)&depth, pBuf, sizeof(xDepth));
  412.         pBuf += sizeof(xDepth);
  413.         sizesofar += sizeof(xDepth);
  414.         for(k = 0; k < pDepth->numVids; k++)
  415.         {
  416.         vid = pDepth->vids[k];
  417.         for (pVisual = pScreen->visuals;
  418.              pVisual->vid != vid;
  419.              pVisual++)
  420.             ;
  421.         visual.visualID = vid;
  422.         visual.class = pVisual->class;
  423.         visual.bitsPerRGB = pVisual->bitsPerRGBValue;
  424.         visual.colormapEntries = pVisual->ColormapEntries;
  425.         visual.redMask = pVisual->redMask;
  426.         visual.greenMask = pVisual->greenMask;
  427.         visual.blueMask = pVisual->blueMask;
  428.         bcopy((char *)&visual, pBuf, sizeof(xVisualType));
  429.         pBuf += sizeof(xVisualType);
  430.         sizesofar += sizeof(xVisualType);
  431.         }
  432.     }
  433.     }
  434.     connSetupPrefix.success = xTrue;
  435.     connSetupPrefix.length = lenofblock/4;
  436.     connSetupPrefix.majorVersion = X_PROTOCOL;
  437.     connSetupPrefix.minorVersion = X_PROTOCOL_REVISION;
  438.     return TRUE;
  439. }
  440.  
  441. static int  screenPrivateCount;
  442.  
  443. static void
  444. ResetScreenPrivates()
  445. {
  446.     screenPrivateCount = 0;
  447. }
  448.  
  449. /* this can be called after some screens have been created,
  450.  * so we have to worry about resizing existing devPrivates
  451.  */
  452. int
  453. AllocateScreenPrivateIndex()
  454. {
  455.     int        index;
  456.     int        i;
  457.     ScreenPtr    pScreen;
  458.     DevUnion    *nprivs;
  459.  
  460.     index = screenPrivateCount++;
  461.     for (i = 0; i < screenInfo.numScreens; i++)
  462.     {
  463.     pScreen = screenInfo.screens[i];
  464.     nprivs = (DevUnion *)xrealloc(pScreen->devPrivates,
  465.                       screenPrivateCount * sizeof(DevUnion));
  466.     if (!nprivs)
  467.     {
  468.         screenPrivateCount--;
  469.         return -1;
  470.     }
  471.     pScreen->devPrivates = nprivs;
  472.     }
  473.     return index;
  474. }
  475.  
  476. Bool
  477. AllocateWindowPrivate(pScreen, index, amount)
  478.     register ScreenPtr pScreen;
  479.     int index;
  480.     unsigned amount;
  481. {
  482.     unsigned oldamount;
  483.  
  484.     if (index >= pScreen->WindowPrivateLen)
  485.     {
  486.     unsigned *nsizes;
  487.     nsizes = (unsigned *)xrealloc(pScreen->WindowPrivateSizes,
  488.                       (index + 1) * sizeof(unsigned));
  489.     if (!nsizes)
  490.         return FALSE;
  491.     while (pScreen->WindowPrivateLen <= index)
  492.     {
  493.         nsizes[pScreen->WindowPrivateLen++] = 0;
  494.         pScreen->totalWindowSize += sizeof(DevUnion);
  495.     }
  496.     pScreen->WindowPrivateSizes = nsizes;
  497.     }
  498.     oldamount = pScreen->WindowPrivateSizes[index];
  499.     if (amount > oldamount)
  500.     {
  501.     pScreen->WindowPrivateSizes[index] = amount;
  502.     pScreen->totalWindowSize += (amount - oldamount);
  503.     }
  504.     return TRUE;
  505. }
  506.  
  507. Bool
  508. AllocateGCPrivate(pScreen, index, amount)
  509.     register ScreenPtr pScreen;
  510.     int index;
  511.     unsigned amount;
  512. {
  513.     unsigned oldamount;
  514.  
  515.     if (index >= pScreen->GCPrivateLen)
  516.     {
  517.     unsigned *nsizes;
  518.     nsizes = (unsigned *)xrealloc(pScreen->GCPrivateSizes,
  519.                       (index + 1) * sizeof(unsigned));
  520.     if (!nsizes)
  521.         return FALSE;
  522.     while (pScreen->GCPrivateLen <= index)
  523.     {
  524.         nsizes[pScreen->GCPrivateLen++] = 0;
  525.         pScreen->totalGCSize += sizeof(DevUnion);
  526.     }
  527.     pScreen->GCPrivateSizes = nsizes;
  528.     }
  529.     oldamount = pScreen->GCPrivateSizes[index];
  530.     if (amount > oldamount)
  531.     {
  532.     pScreen->GCPrivateSizes[index] = amount;
  533.     pScreen->totalGCSize += (amount - oldamount);
  534.     }
  535.     return TRUE;
  536. }
  537.  
  538. /*
  539.     grow the array of screenRecs if necessary.
  540.     call the device-supplied initialization procedure 
  541. with its screen number, a pointer to its ScreenRec, argc, and argv.
  542.     return the number of successfully installed screens.
  543.  
  544. */
  545.  
  546. int
  547. AddScreen(pfnInit, argc, argv)
  548.     Bool    (* pfnInit)();
  549.     int argc;
  550.     char **argv;
  551. {
  552.  
  553.     int i;
  554.     int scanlinepad, format, depth, bitsPerPixel, j, k;
  555.     ScreenPtr pScreen;
  556. #ifdef DEBUG
  557.     void    (**jNI) ();
  558. #endif /* DEBUG */
  559.  
  560.     i = screenInfo.numScreens;
  561.     if (i == MAXSCREENS)
  562.     return -1;
  563.  
  564.     pScreen = (ScreenPtr) xalloc(sizeof(ScreenRec));
  565.     if (!pScreen)
  566.     return -1;
  567.  
  568.     pScreen->devPrivates = (DevUnion *)xalloc(screenPrivateCount *
  569.                           sizeof(DevUnion));
  570.     if (!pScreen->devPrivates && screenPrivateCount)
  571.     {
  572.     xfree(pScreen);
  573.     return -1;
  574.     }
  575.     pScreen->myNum = i;
  576.     pScreen->WindowPrivateLen = 0;
  577.     pScreen->WindowPrivateSizes = (unsigned *)NULL;
  578.     pScreen->totalWindowSize = sizeof(WindowRec);
  579.     pScreen->GCPrivateLen = 0;
  580.     pScreen->GCPrivateSizes = (unsigned *)NULL;
  581.     pScreen->totalGCSize = sizeof(GC);
  582.     
  583. #ifdef DEBUG
  584.     for (jNI = &pScreen->QueryBestSize; 
  585.      jNI < (void (**) ()) &pScreen->SendGraphicsExpose;
  586.      jNI++)
  587.     *jNI = NotImplemented;
  588. #endif /* DEBUG */
  589.  
  590.     /*
  591.      * This loop gets run once for every Screen that gets added,
  592.      * but thats ok.  If the ddx layer initializes the formats
  593.      * one at a time calling AddScreen() after each, then each
  594.      * iteration will make it a little more accurate.  Worst case
  595.      * we do this loop N * numPixmapFormats where N is # of screens.
  596.      * Anyway, this must be called after InitOutput and before the
  597.      * screen init routine is called.
  598.      */
  599.     for (format=0; format<screenInfo.numPixmapFormats; format++)
  600.     {
  601.      depth = screenInfo.formats[format].depth;
  602.      bitsPerPixel = screenInfo.formats[format].bitsPerPixel;
  603.       scanlinepad = screenInfo.formats[format].scanlinePad;
  604.      j = indexForBitsPerPixel[ bitsPerPixel ];
  605.       k = indexForScanlinePad[ scanlinepad ];
  606.      PixmapWidthPaddingInfo[ depth ].padPixelsLog2 = answer[j][k];
  607.      PixmapWidthPaddingInfo[ depth ].padRoundUp =
  608.          (scanlinepad/bitsPerPixel) - 1;
  609.      j = indexForBitsPerPixel[ 8 ]; /* bits per byte */
  610.      PixmapWidthPaddingInfo[ depth ].padBytesLog2 = answer[j][k];
  611.     }
  612.   
  613.     /* This is where screen specific stuff gets initialized.  Load the
  614.        screen structure, call the hardware, whatever.
  615.        This is also where the default colormap should be allocated and
  616.        also pixel values for blackPixel, whitePixel, and the cursor
  617.        Note that InitScreen is NOT allowed to modify argc, argv, or
  618.        any of the strings pointed to by argv.  They may be passed to
  619.        multiple screens. 
  620.     */ 
  621.     pScreen->rgf = ~0L;  /* there are no scratch GCs yet*/
  622.     WindowTable[i] = NullWindow;
  623.     screenInfo.screens[i] = pScreen;
  624.     screenInfo.numScreens++;
  625.     if ((*pfnInit)(i, pScreen, argc, argv))
  626.     {
  627.     if (CreateGCperDepth(i))
  628.     {
  629.         if (CreateDefaultStipple(i))
  630.         return i;
  631.         FreeGCperDepth(i);
  632.     }
  633.     FreeResource(WindowTable[i]->drawable.id, RT_NONE);
  634.     }
  635.     FreeScreen(pScreen);
  636.     screenInfo.numScreens--;
  637.     return -1;
  638. }
  639.  
  640. static void
  641. FreeScreen(pScreen)
  642.     ScreenPtr pScreen;
  643. {
  644.     xfree(pScreen->WindowPrivateSizes);
  645.     xfree(pScreen->GCPrivateSizes);
  646.     xfree(pScreen->devPrivates);
  647.     xfree(pScreen);
  648. }
  649. @
  650.